// pages/profile/profile.js
Page({
  data: {
    userInfo: null,
    hasUserInfo: false,
    canIUseGetUserProfile: false,
    showNicknameModal: false,
    editingNickname: '',
    currentMotivation: '',
    motivationalQuotes: [
      "每一次记录，都是对健康的珍视",
      "了解自己，才能更好地照顾自己",
      "规律生活，健康相伴",
      "小小记录，大大改变",
      "关注周期，关爱自己",
      "坚持记录，收获健康",
      "了解身体，从记录开始",
      "自律即自由，记录助你成长",
      "今天的记录，是明天的健康指南",
      "用数据说话，让健康看得见",
      "每一次记录都是自我关爱的表现",
      "掌握规律，掌握健康",
      "健康生活，从记录开始",
      "了解自己，爱护自己",
      "记录点滴，关爱无限"
    ],
    cycleSummary: {
      average: '29',
      regularity: '较规律',
      months: [
        { month: '四月', days: 28, height: 140 },
        { month: '五月', days: 30, height: 160 },
        { month: '六月', days: 27, height: 120 },
        { month: '七月', days: 31, height: 180, active: true }
      ]
    }
  },

  onLoad: function() {
    // 注册页面实例到全局，用于头像联动
    const app = getApp()
    app.globalData.profilePageInstance = this

    // 初始化云环境
    if (!wx.cloud) {
      console.error('请使用 2.2.3 或以上的基础库以使用云能力');
    } else {
      wx.cloud.init({
        env: 'cloud1-5g4tah1p0a136da2',
        traceUser: true,
      });
    }

    // 判断环境是否支持 getUserProfile
    if (wx.getUserProfile) {
      this.setData({
        canIUseGetUserProfile: true
      });
    }

    // 随机选择一条激励语，但不显示提示
    this.initMotivation();
    
    // 检查本地存储中是否有用户信息
    const userInfo = wx.getStorageSync('userInfo');
    if (userInfo) {
      this.setData({
        userInfo: userInfo,
        hasUserInfo: true
      });
    }
  },
  
  onShow: function() {
    // 每次显示页面时，同步最新的用户信息
    const userInfo = wx.getStorageSync('userInfo')
    if (userInfo) {
      this.setData({
        userInfo: userInfo,
        hasUserInfo: !userInfo.isGuest
      })
    }

    // 每次页面显示时，如果用户已登录，刷新头像URL
    if (this.data.hasUserInfo && this.data.userInfo && this.data.userInfo.avatarUrl) {
      // 如果是云存储头像，刷新临时URL
      if (this.data.userInfo.avatarUrl.indexOf('cloud://') === 0) {
        this.refreshAvatarUrl(this.data.userInfo.avatarUrl);
      }
      // 如果是普通URL，添加时间戳参数
      else {
        const userInfo = this.data.userInfo;
        const timestamp = userInfo.avatarTimestamp || new Date().getTime();
        let avatarUrl = userInfo.avatarUrl;

        // 如果URL中已有参数，添加&v=timestamp，否则添加?v=timestamp
        if (avatarUrl.indexOf('?') > -1 && avatarUrl.indexOf('v=') === -1) {
          avatarUrl += '&v=' + timestamp;
        } else if (avatarUrl.indexOf('?') === -1) {
          avatarUrl += '?v=' + timestamp;
        }

        userInfo.tempAvatarUrl = avatarUrl;
        this.setData({
          userInfo: userInfo
        });
      }
    }
  },

  onUnload: function() {
    // 清理页面实例引用
    const app = getApp()
    if (app.globalData.profilePageInstance === this) {
      app.globalData.profilePageInstance = null
    }
  },

  // 刷新头像URL
  refreshAvatarUrl: function(fileID) {
    const that = this;
    wx.cloud.getTempFileURL({
      fileList: [fileID],
      success: function(res) {
        if (res.fileList && res.fileList[0] && res.fileList[0].tempFileURL) {
          const userInfo = that.data.userInfo;
          // 添加时间戳参数以避免缓存
          let tempUrl = res.fileList[0].tempFileURL;
          const timestamp = userInfo.avatarTimestamp || new Date().getTime();
          tempUrl += (tempUrl.indexOf('?') > -1 ? '&' : '?') + 'v=' + timestamp;
          
          userInfo.tempAvatarUrl = tempUrl;
          that.setData({
            userInfo: userInfo
          });
        }
      },
      fail: function(err) {
        console.error('获取临时头像URL失败:', err);
      }
    });
  },
  
  // 检查用户登录状态
  checkUserLoginStatus: function() {
    const that = this;
    
    // 获取本地存储的用户信息
    const userInfo = wx.getStorageSync('userInfo');
    
    if (userInfo) {
      that.setData({
        userInfo: userInfo,
        hasUserInfo: true
      });
    } else {
      // 尝试从云数据库获取用户信息
      wx.cloud.callFunction({
        name: 'getOpenId',
        success: res => {
          const openid = res.result.openid;
          // 根据openid查询用户信息
          const db = wx.cloud.database();
          db.collection('users').where({
            _openid: openid
          }).get({
            success: function(res) {
              if (res.data.length > 0) {
                const userInfo = res.data[0];
                
                // 如果有头像，确保获取有效的头像URL
                if (userInfo.avatarUrl && userInfo.avatarUrl.includes('cloud')) {
                  wx.cloud.getTempFileURL({
                    fileList: [userInfo.avatarUrl],
                    success: function(fileRes) {
                      // 添加时间戳参数以避免缓存
                      let tempUrl = fileRes.fileList[0].tempFileURL;
                      const timestamp = userInfo.avatarTimestamp || new Date().getTime();
                      tempUrl += (tempUrl.indexOf('?') > -1 ? '&' : '?') + 'v=' + timestamp;
                      
                      userInfo.avatarUrl = tempUrl;
                      wx.setStorageSync('userInfo', userInfo);
                      that.setData({
                        userInfo: userInfo,
                        hasUserInfo: true
                      });
                    },
                    fail: function(err) {
                      console.error('获取头像URL失败:', err);
                      wx.setStorageSync('userInfo', userInfo);
                      that.setData({
                        userInfo: userInfo,
                        hasUserInfo: true
                      });
                    }
                  });
                } else {
                  wx.setStorageSync('userInfo', userInfo);
                  that.setData({
                    userInfo: userInfo,
                    hasUserInfo: true
                  });
                }
              }
            }
          });
        }
      });
    }
  },
  
  // 获取用户信息
  getUserProfile: function() {
    const that = this;
    
    // 显示加载中
    wx.showLoading({
      title: '登录中...',
      mask: true
    });
    
    wx.getUserProfile({
      desc: '用于完善用户资料',
      success: (res) => {
        // 获取到用户信息
        const userInfo = res.userInfo;
        
        // 如果用户昵称是"微信用户"，设置默认昵称
        if (!userInfo.nickName || userInfo.nickName.trim() === '' || userInfo.nickName === '微信用户') {
          userInfo.nickName = "起个喜欢的名字吧~";
        }
        
        // 如果用户头像是默认头像，随机选择一个默认头像
        if (this.isDefaultAvatar(userInfo.avatarUrl)) {
          const randomImg = this.getRandomDefaultAvatar();
          userInfo.avatarUrl = randomImg;
        }
        
        // 调用云函数获取openid
        wx.cloud.callFunction({
          name: 'getOpenId',
          success: function(openidRes) {
            const openid = openidRes.result.openid;
            
            // 将用户信息存入云数据库
            const db = wx.cloud.database();
            
            // 先查询该用户是否已存在
            db.collection('users').where({
              _openid: openid
            }).get().then(checkRes => {
              if (checkRes.data.length === 0) {
                // 新用户，添加到数据库
                // 注意：不要手动设置 _openid 字段，云函数会自动添加
                const timestamp = new Date().getTime(); // 添加时间戳
                db.collection('users').add({
                  data: {
                    nickName: userInfo.nickName,
                    avatarUrl: userInfo.avatarUrl,
                    avatarTimestamp: timestamp, // 保存时间戳
                    gender: userInfo.gender,
                    country: userInfo.country,
                    province: userInfo.province,
                    city: userInfo.city,
                    registerTime: db.serverDate(),
                    lastLoginTime: db.serverDate()
                  }
                }).then(() => {
                  // 添加时间戳到本地存储
                  userInfo.avatarTimestamp = timestamp;
                  // 添加本地存储
                  wx.setStorageSync('userInfo', userInfo);
                  that.setData({
                    userInfo: userInfo,
                    hasUserInfo: true
                  });
                  wx.hideLoading();
                  wx.showToast({
                    title: '登录成功',
                    icon: 'success'
                  });
                }).catch(err => {
                  console.error('添加用户失败:', err);
                  wx.hideLoading();
                  wx.showToast({
                    title: '登录失败',
                    icon: 'none'
                  });
                });
              } else {
                // 老用户，使用数据库中已有的信息（包括用户可能修改过的昵称和头像）
                const dbUserInfo = checkRes.data[0];
                const userId = dbUserInfo._id;
                
                // 更新或使用现有时间戳
                const timestamp = dbUserInfo.avatarTimestamp || new Date().getTime();
                
                // 确定要使用的昵称
                let finalNickName;
                
                // 如果数据库中已有昵称且不是"微信用户"，则使用数据库中的昵称
                if (dbUserInfo.nickName && dbUserInfo.nickName !== '微信用户') {
                  finalNickName = dbUserInfo.nickName;
                } 
                // 否则如果微信提供的昵称不是"微信用户"，则使用微信提供的昵称
                else if (userInfo.nickName && userInfo.nickName !== '微信用户') {
                  finalNickName = userInfo.nickName;
                } 
                // 如果都是"微信用户"或为空，则使用默认昵称
                else {
                  finalNickName = "起个喜欢的名字吧~";
                }
                
                // 确定要使用的头像
                let finalAvatarUrl;
                
                // 如果数据库中已有自定义头像，则使用数据库中的头像
                if (dbUserInfo.avatarUrl && !that.isDefaultAvatar(dbUserInfo.avatarUrl)) {
                  finalAvatarUrl = dbUserInfo.avatarUrl;
                }
                // 否则如果微信提供的头像不是默认头像，则使用微信提供的头像
                else if (userInfo.avatarUrl && !that.isDefaultAvatar(userInfo.avatarUrl)) {
                  finalAvatarUrl = userInfo.avatarUrl;
                }
                // 如果都是默认头像或为空，则使用随机默认头像
                else {
                  finalAvatarUrl = that.getRandomDefaultAvatar();
                }
                
                // 只更新登录时间，保留用户自定义的昵称和头像
                db.collection('users').doc(userId).update({
                  data: {
                    lastLoginTime: db.serverDate(),
                    // 只更新微信未提供或用户未修改过的信息
                    gender: userInfo.gender,
                    country: userInfo.country,
                    province: userInfo.province,
                    city: userInfo.city,
                    // 更新昵称
                    nickName: finalNickName,
                    // 更新头像
                    avatarUrl: finalAvatarUrl,
                    // 如果没有时间戳，添加时间戳
                    avatarTimestamp: timestamp
                  }
                }).then(() => {
                  // 合并微信提供的信息和数据库中的信息
                  // 优先使用数据库中的昵称和头像
                  const mergedUserInfo = {
                    ...userInfo,
                    nickName: finalNickName,
                    avatarUrl: finalAvatarUrl,
                    avatarTimestamp: timestamp // 添加时间戳
                  };
                  
                  // 如果头像是云存储路径，立即获取临时URL
                  if (mergedUserInfo.avatarUrl && mergedUserInfo.avatarUrl.indexOf('cloud://') === 0) {
                    wx.cloud.getTempFileURL({
                      fileList: [mergedUserInfo.avatarUrl],
                      success: function(fileRes) {
                        if (fileRes.fileList && fileRes.fileList[0] && fileRes.fileList[0].tempFileURL) {
                          // 添加时间戳参数以避免缓存
                          let tempUrl = fileRes.fileList[0].tempFileURL;
                          tempUrl += (tempUrl.indexOf('?') > -1 ? '&' : '?') + 'v=' + timestamp;
                          
                          // 保存原始云存储路径和临时URL
                          mergedUserInfo.tempAvatarUrl = tempUrl;
                          
                          // 更新本地存储和界面
                          wx.setStorageSync('userInfo', mergedUserInfo);
                          that.setData({
                            userInfo: mergedUserInfo,
                            hasUserInfo: true
                          });
                          wx.hideLoading();
                          wx.showToast({
                            title: '登录成功',
                            icon: 'success'
                          });
                        }
                      },
                      fail: function(err) {
                        console.error('获取头像临时URL失败:', err);
                        // 即使获取临时URL失败，也继续登录流程
                        wx.setStorageSync('userInfo', mergedUserInfo);
                        that.setData({
                          userInfo: mergedUserInfo,
                          hasUserInfo: true
                        });
                        wx.hideLoading();
                        wx.showToast({
                          title: '登录成功',
                          icon: 'success'
                        });
                      }
                    });
                  } else {
                    // 如果不是云存储路径，直接更新
                    wx.setStorageSync('userInfo', mergedUserInfo);
                    that.setData({
                      userInfo: mergedUserInfo,
                      hasUserInfo: true
                    });
                    wx.hideLoading();
                    wx.showToast({
                      title: '登录成功',
                      icon: 'success'
                    });
                  }
                }).catch(err => {
                  console.error('更新用户信息失败:', err);
                  wx.hideLoading();
                  wx.showToast({
                    title: '登录失败',
                    icon: 'none'
                  });
                });
              }
            }).catch(err => {
              console.error('查询用户失败:', err);
              wx.hideLoading();
              wx.showToast({
                title: '登录失败',
                icon: 'none'
              });
            });
          },
          fail: err => {
            console.error('获取OpenID失败:', err);
            wx.hideLoading();
            wx.showToast({
              title: '登录失败',
              icon: 'none'
            });
          }
        });
      },
      fail: (res) => {
        wx.hideLoading();
        wx.showToast({
          title: '您已取消登录',
          icon: 'none'
        });
      }
    });
  },
  
  // 判断是否为默认头像
  isDefaultAvatar: function(avatarUrl) {
    if (!avatarUrl) return true;
    
    // 检查是否为微信默认头像（一般包含 "wxfile:" 或特定的默认头像URL模式）
    if (avatarUrl.includes('wxfile:') || 
        avatarUrl.includes('https://thirdwx.qlogo.cn/mmopen/vi_32/POgEwh') ||
        avatarUrl === 'https://mmbiz.qpic.cn/mmbiz/icTdbqWNOwNRna42FI242Lcia07jQodd2FJGIYQfG0LAJGFxM4FbnQP6yfMxBgJ0F3YRqJCJ1aPAK2dQagdusBZg/0') {
      return true;
    }
    
    return false;
  },
  
  // 获取随机默认头像
  getRandomDefaultAvatar: function() {
    const defaultAvatars = [
      '/images/img1.jpg',
    ];
    
    // 随机选择一个头像
    const randomIndex = Math.floor(Math.random() * defaultAvatars.length);
    return defaultAvatars[randomIndex];
  },
  
  // 编辑昵称
  editNickname: function() {
    this.setData({
      showNicknameModal: true,
      editingNickname: this.data.userInfo.nickName
    });
  },
  
  // 昵称输入事件
  onNicknameInput: function(e) {
    this.setData({
      editingNickname: e.detail.value
    });
  },
  
  // 取消编辑昵称
  cancelEditNickname: function() {
    this.setData({
      showNicknameModal: false,
      editingNickname: ''
    });
  },
  
  // 确认修改昵称
  confirmEditNickname: function() {
    const that = this;
    const newNickname = this.data.editingNickname.trim();
    
    if (!newNickname) {
      wx.showToast({
        title: '昵称不能为空',
        icon: 'none'
      });
      return;
    }
    
    // 显示加载中
    wx.showLoading({
      title: '保存中...',
      mask: true
    });
    
    // 获取用户OpenID
    wx.cloud.callFunction({
      name: 'getOpenId',
      success: function(res) {
        const openid = res.result.openid;
        
        // 更新数据库中的昵称
        const db = wx.cloud.database();
        db.collection('users').where({
          _openid: openid
        }).get().then(userRes => {
          if (userRes.data.length > 0) {
            const userId = userRes.data[0]._id;
            
            // 更新数据库
            db.collection('users').doc(userId).update({
              data: {
                nickName: newNickname,
                lastUpdateTime: db.serverDate()
              }
            }).then(() => {
              // 更新本地存储和界面
              const userInfo = that.data.userInfo;
              userInfo.nickName = newNickname;

              // 使用全局方法更新所有页面的用户信息
              const app = getApp();
              app.updateUserInfoToAllPages(userInfo);

              that.setData({
                showNicknameModal: false,
                editingNickname: ''
              });

              wx.hideLoading();
              wx.showToast({
                title: '昵称修改成功',
                icon: 'success'
              });
            }).catch(err => {
              wx.hideLoading();
              console.error('更新昵称失败:', err);
              wx.showToast({
                title: '昵称修改失败',
                icon: 'none'
              });
            });
          } else {
            wx.hideLoading();
            wx.showToast({
              title: '用户信息获取失败',
              icon: 'none'
            });
          }
        }).catch(err => {
          wx.hideLoading();
          console.error('获取用户信息失败:', err);
          wx.showToast({
            title: '用户信息获取失败',
            icon: 'none'
          });
        });
      },
      fail: function(err) {
        wx.hideLoading();
        console.error('获取OpenID失败:', err);
        wx.showToast({
          title: '操作失败',
          icon: 'none'
        });
      }
    });
  },
  
  // 编辑头像
  editAvatar: function() {
    const that = this;
    
    // 获取用户OpenID，用作头像文件名
    wx.cloud.callFunction({
      name: 'getOpenId',
      success: function(res) {
        const openid = res.result.openid;
        
        // 选择图片
        wx.chooseMedia({
          count: 1,
          mediaType: ['image'],
          sourceType: ['album', 'camera'],
          camera: 'back',
          success: function(res) {
            const tempFilePath = res.tempFiles[0].tempFilePath;
            
            // 显示上传中
            wx.showLoading({
              title: '上传中...',
              mask: true
            });
            
            // 上传图片到云存储，使用固定文件名，覆盖旧文件
            const cloudPath = `avatars/${openid}_avatar.jpg`;
            wx.cloud.uploadFile({
              cloudPath: cloudPath,
              filePath: tempFilePath,
              success: function(uploadRes) {
                // 获取图片的云存储地址
                const fileID = uploadRes.fileID;
                
                // 设置文件为公有读取权限
                wx.cloud.callFunction({
                  name: 'setFilePublic',
                  data: {
                    fileID: fileID
                  },
                  success: function(res) {
                    console.log('设置文件公有读取权限成功', res);
                  },
                  fail: function(err) {
                    console.error('设置文件公有读取权限失败', err);
                  }
                });
                
                // 获取临时访问链接
                wx.cloud.getTempFileURL({
                  fileList: [fileID],
                  success: function(fileRes) {
                    const avatarUrl = fileRes.fileList[0].tempFileURL;
                    
                    // 构建一个长期有效的URL（使用fileID）
                    const permanentAvatarUrl = fileID;
                    
                    // 更新用户头像
                    const db = wx.cloud.database();
                    db.collection('users').where({
                      _openid: openid
                    }).get().then(userRes => {
                      if (userRes.data.length > 0) {
                        const userId = userRes.data[0]._id;
                        
                        // 获取当前时间戳作为缓存打破参数
                        const timestamp = new Date().getTime();
                        
                        // 更新数据库中的头像
                        db.collection('users').doc(userId).update({
                          data: {
                            avatarUrl: permanentAvatarUrl,
                            avatarTimestamp: timestamp, // 保存时间戳到数据库
                            lastUpdateTime: db.serverDate()
                          }
                        }).then(() => {
                          // 更新本地存储和界面
                          const userInfo = that.data.userInfo;
                          userInfo.avatarUrl = permanentAvatarUrl;
                          userInfo.avatarTimestamp = timestamp; // 在本地也保存时间戳

                          // 添加时间戳参数以避免缓存
                          let tempUrl = avatarUrl;
                          tempUrl += (tempUrl.indexOf('?') > -1 ? '&' : '?') + 'v=' + timestamp;

                          // 立即更新临时URL到界面显示
                          userInfo.tempAvatarUrl = tempUrl;

                          // 使用全局方法更新所有页面的用户信息
                          const app = getApp();
                          app.updateUserInfoToAllPages(userInfo);

                          wx.hideLoading();
                          wx.showToast({
                            title: '头像更新成功',
                            icon: 'success'
                          });
                        }).catch(err => {
                          wx.hideLoading();
                          console.error('更新头像失败:', err);
                          wx.showToast({
                            title: '头像更新失败',
                            icon: 'none'
                          });
                        });
                      } else {
                        wx.hideLoading();
                        wx.showToast({
                          title: '用户信息获取失败',
                          icon: 'none'
                        });
                      }
                    }).catch(err => {
                      wx.hideLoading();
                      console.error('获取用户信息失败:', err);
                      wx.showToast({
                        title: '用户信息获取失败',
                        icon: 'none'
                      });
                    });
                  },
                  fail: function(err) {
                    wx.hideLoading();
                    console.error('获取临时链接失败:', err);
                    wx.showToast({
                      title: '头像更新失败',
                      icon: 'none'
                    });
                  }
                });
              },
              fail: function(err) {
                wx.hideLoading();
                console.error('上传头像失败:', err);
                wx.showToast({
                  title: '头像上传失败',
                  icon: 'none'
                });
              }
            });
          },
          fail: function(err) {
            console.error('选择图片失败:', err);
          }
        });
      },
      fail: function(err) {
        console.error('获取OpenID失败:', err);
        wx.showToast({
          title: '操作失败',
          icon: 'none'
        });
      }
    });
  },
  
  // 退出登录
  logout: function() {
    wx.showModal({
      title: '提示',
      content: '确定要退出登录吗？',
      success: (res) => {
        if (res.confirm) {
          wx.removeStorageSync('userInfo');
          this.setData({
            userInfo: null,
            hasUserInfo: false
          });
          wx.showToast({
            title: '已退出登录',
            icon: 'success'
          });
        }
      }
    });
  },

  viewCycleDetails: function() {
    wx.showToast({
      title: '周期详情页面开发中',
      icon: 'none'
    });
  },

  // Cell item handlers
  onCellClick: function(e) {
    const { currentTarget: { dataset: { type } } } = e;
    
    switch(type) {
      case 'settings':
        this.navigateToSettings();
        break;
      case 'notifications':
        this.navigateToNotifications();
        break;
      case 'privacy':
        this.navigateToPrivacy();
        break;
      case 'export':
        this.handleExport();
        break;
      case 'about':
        this.showAbout();
        break;
      case 'help':
        this.showHelp();
        break;
      default:
        console.log('Unknown cell type:', type);
    }
  },

  navigateToSettings: function() {
    wx.showToast({
      title: '设置页面开发中',
      icon: 'none'
    });
  },

  navigateToNotifications: function() {
    wx.showToast({
      title: '通知页面开发中',
      icon: 'none'
    });
  },

  navigateToPrivacy: function() {
    wx.showToast({
      title: '隐私设置页面开发中',
      icon: 'none'
    });
  },

  handleExport: function() {
    wx.showToast({
      title: '数据导出功能开发中',
      icon: 'none'
    });
  },

  showAbout: function() {
    wx.showToast({
      title: '关于我们页面开发中',
      icon: 'none'
    });
  },

  showHelp: function() {
    wx.showToast({
      title: '帮助与反馈页面开发中',
      icon: 'none'
    });
  },

  // 刷新激励语
  initMotivation: function() {
    const quotes = this.data.motivationalQuotes;
    const randomIndex = Math.floor(Math.random() * quotes.length);
    this.setData({
      currentMotivation: quotes[randomIndex]
    });
  },

  // 刷新激励语，并显示提示
  refreshMotivation: function() {
    // 先显示微信默认Toast通知
    wx.showToast({
      title: '换个心情！',
      icon: 'none',
      duration: 2000
    });
    
    // 然后更新激励语
    const quotes = this.data.motivationalQuotes;
    const randomIndex = Math.floor(Math.random() * quotes.length);
    this.setData({
      currentMotivation: quotes[randomIndex]
    });
  },

  // 头像加载错误处理
  onAvatarError: function() {
    console.log('头像加载失败，使用默认头像');
    // 如果用户信息存在，更新头像为默认头像
    if (this.data.userInfo) {
      const userInfo = this.data.userInfo;
      // 使用一个网络默认头像
      userInfo.avatarUrl = 'https://mmbiz.qpic.cn/mmbiz/icTdbqWNOwNRna42FI242Lcia07jQodd2FJGIYQfG0LAJGFxM4FbnQP6yfMxBgJ0F3YRqJCJ1aPAK2dQagdusBZg/0';
      this.setData({
        userInfo: userInfo
      });
    }
  }
}); 